home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / fsrmt / fsrmtMigrate.c < prev    next >
C/C++ Source or Header  |  1992-12-18  |  7KB  |  195 lines
  1. /*
  2.  * fsRmtMigrate.c --
  3.  *
  4.  * Procedures to handle migrating open files between machines.  The basic
  5.  * strategy is to first do some local book-keeping on the client we are
  6.  * leaving, then ship state to the new client, then finally tell the
  7.  * I/O server about it, and finish up with local book-keeping on the
  8.  * new client.  There are three stream-type procedures used: 'migStart'
  9.  * does the initial book-keeping on the original client, 'migEnd' does
  10.  * the final book-keeping on the new client, and 'migrate' is called
  11.  * on the I/O server to shift around state associated with the client.
  12.  *
  13.  * Copyright (C) 1985, 1988, 1989 Regents of the University of California
  14.  * Permission to use, copy, modify, and distribute this
  15.  * software and its documentation for any purpose and without
  16.  * fee is hereby granted, provided that the above copyright
  17.  * notice appear in all copies.  The University of California
  18.  * makes no representations about the suitability of this
  19.  * software for any purpose.  It is provided "as is" without
  20.  * express or implied warranty.
  21.  */
  22.  
  23. #ifndef lint
  24. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/fsrmt/fsrmtMigrate.c,v 9.3 91/09/10 18:23:56 rab Exp $ SPRITE (Berkeley)";
  25. #endif not lint
  26.  
  27.  
  28. #include <sprite.h>
  29. #include <fs.h>
  30. #include <fsutil.h>
  31. #include <fsconsist.h>
  32. #include <fsrmtMigrate.h>
  33. #include <fsio.h>
  34. #include <fspdev.h>
  35. #include <fsprefix.h>
  36. #include <fsNameOps.h>
  37. #include <byte.h>
  38. #include <rpc.h>
  39. #include <procMigrate.h>
  40.  
  41. #include <stdio.h>
  42.  
  43. extern Boolean fsio_MigDebug;
  44. #define DEBUG( format ) \
  45.     if (fsio_MigDebug) { printf format ; }
  46.  
  47.  
  48.  
  49. /*
  50.  *----------------------------------------------------------------------
  51.  *
  52.  * Fsrmt_NotifyOfMigration --
  53.  *
  54.  *    This invokes the stream-specific migration routine on the I/O server.
  55.  *    This is used by various RMT (remote) stream types.
  56.  *
  57.  * Results:
  58.  *    A return status, plus new flags containing FS_RMT_SHARED bit,
  59.  *    a new stream offset, plus some stream-type-specific data used
  60.  *    when creating the I/O handle in the migEnd procedure.
  61.  *
  62.  * Side effects:
  63.  *      None here, but bookkeeping is done at the I/O server.
  64.  *    
  65.  *----------------------------------------------------------------------
  66.  */
  67. ReturnStatus
  68. Fsrmt_NotifyOfMigration(migInfoPtr, flagsPtr, offsetPtr, outSize, outData)
  69.     Fsio_MigInfo    *migInfoPtr;    /* Encapsulated information */
  70.     int        *flagsPtr;    /* New flags, may have FS_RMT_SHARED bit set */
  71.     int        *offsetPtr;    /* New stream offset */
  72.     int        outSize;    /* Size of returned data, outData */
  73.     Address    outData;    /* Returned data from server */
  74. {
  75.     register ReturnStatus    status;
  76.     Rpc_Storage     storage;
  77.     FsrmtMigParam        migParam;
  78.  
  79.     storage.requestParamPtr = (Address) migInfoPtr;
  80.     storage.requestParamSize = sizeof(Fsio_MigInfo);
  81.     storage.requestDataPtr = (Address)NIL;
  82.     storage.requestDataSize = 0;
  83.  
  84.     storage.replyParamPtr = (Address)&migParam;
  85.     storage.replyParamSize = sizeof(FsrmtMigParam);
  86.     storage.replyDataPtr = (Address) NIL;
  87.     storage.replyDataSize = 0;
  88.  
  89.     status = Rpc_Call(migInfoPtr->ioFileID.serverID, RPC_FS_MIGRATE, &storage);
  90.  
  91.     if (status == SUCCESS) {
  92.     FsrmtMigrateReply    *migReplyPtr;
  93.  
  94.     migReplyPtr = &(migParam.migReply);
  95.     *flagsPtr = migReplyPtr->flags;
  96.     *offsetPtr = migReplyPtr->offset;
  97.     if (migParam.dataSize > 0) {
  98.         if (outSize < migParam.dataSize) {
  99.         panic("Fsrmt_NotifyOfMigration: too much data returned %d not %d\n",
  100.               migParam.dataSize, outSize);
  101.         status = FAILURE;
  102.         } else {
  103.         bcopy((Address)&migParam.data, outData, migParam.dataSize);
  104.         }
  105.     }
  106.     } else if (fsio_MigDebug) {
  107.     printf("Fsrmt_NotifyOfMigration: status %x from remote migrate routine.\n",
  108.           status);
  109.     }
  110.     return(status);
  111. }
  112.  
  113. /*
  114.  *----------------------------------------------------------------------
  115.  *
  116.  * Fsrmt_RpcMigrateStream --
  117.  *
  118.  *    The RPC service stub for Fsrmt_NotifyOfMigration.
  119.  *    This invokes the Migrate routine for the I/O handle given in
  120.  *    the encapsulated stream state.
  121.  *
  122.  * Results:
  123.  *    FS_STALE_HANDLE if handle that if client that is migrating the file
  124.  *    doesn't have the file opened on this machine.  Otherwise return
  125.  *    SUCCESS.
  126.  *
  127.  * Side effects:
  128.  *    None.
  129.  *
  130.  *----------------------------------------------------------------------
  131.  */
  132. /*ARGSUSED*/
  133. ReturnStatus
  134. Fsrmt_RpcMigrateStream(srvToken, clientID, command, storagePtr)
  135.     ClientData srvToken;    /* Handle on server process passed to
  136.                  * Rpc_Reply */
  137.     int clientID;        /* Sprite ID of client host */
  138.     int command;        /* Command identifier */
  139.     Rpc_Storage *storagePtr;    /* The request fields refer to the request
  140.                  * buffers and also indicate the exact amount
  141.                  * of data in the request buffers.  The reply
  142.                  * fields are initialized to NIL for the
  143.                  * pointers and 0 for the lengths.  This can
  144.                  * be passed to Rpc_Reply */
  145. {
  146.     register Fsio_MigInfo        *migInfoPtr;
  147.     register Fs_HandleHeader    *hdrPtr;
  148.     register ReturnStatus    status;
  149.     register FsrmtMigrateReply    *migReplyPtr;
  150.     register FsrmtMigParam        *migParamPtr;
  151.     register Rpc_ReplyMem    *replyMemPtr;
  152.     Address                dataPtr;
  153.     int                dataSize;
  154.  
  155.     migInfoPtr = (Fsio_MigInfo *) storagePtr->requestParamPtr;
  156.  
  157.     hdrPtr = (*fsio_StreamOpTable[migInfoPtr->ioFileID.type].clientVerify)
  158.         (&migInfoPtr->ioFileID, migInfoPtr->srcClientID, (int *)NIL);
  159.     if (hdrPtr == (Fs_HandleHeader *) NIL) {
  160.     printf("Fsrmt_RpcMigrateStream, unknown %s handle <%d,%d>\n",
  161.         Fsutil_FileTypeToString(migInfoPtr->ioFileID.type),
  162.         migInfoPtr->ioFileID.major, migInfoPtr->ioFileID.minor);
  163.     return(FS_STALE_HANDLE);
  164.     }
  165.     Fsutil_HandleUnlock(hdrPtr);
  166.     migParamPtr = mnew(FsrmtMigParam);
  167.     migReplyPtr = &(migParamPtr->migReply);
  168.     migReplyPtr->flags = migInfoPtr->flags;
  169.     storagePtr->replyParamPtr = (Address)migParamPtr;
  170.     storagePtr->replyParamSize = sizeof(FsrmtMigParam);
  171.     storagePtr->replyDataPtr = (Address)NIL;
  172.     storagePtr->replyDataSize = 0;
  173.     status = (*fsio_StreamOpTable[hdrPtr->fileID.type].migrate) (migInfoPtr,
  174.         clientID, &migReplyPtr->flags, &migReplyPtr->offset,
  175.         &dataSize, &dataPtr);
  176.     migParamPtr->dataSize = dataSize;
  177.     if ((status == SUCCESS) && (dataSize > 0)) {
  178.     if (dataSize <= sizeof(migParamPtr->data)) {
  179.         bcopy(dataPtr, (Address) &migParamPtr->data, dataSize);
  180.         free(dataPtr);
  181.     } else {
  182.         panic("Fsrmt_RpcMigrateStream: migrate returned oversized buffer.\n");
  183.         return(FAILURE);
  184.     }
  185.     } 
  186.     Fsutil_HandleRelease(hdrPtr, FALSE);
  187.  
  188.     replyMemPtr = (Rpc_ReplyMem *) malloc(sizeof(Rpc_ReplyMem));
  189.     replyMemPtr->paramPtr = storagePtr->replyParamPtr;
  190.     replyMemPtr->dataPtr = (Address) NIL;
  191.     Rpc_Reply(srvToken, status, storagePtr, Rpc_FreeMem,
  192.         (ClientData)replyMemPtr);
  193.     return(SUCCESS);
  194. }
  195.